home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / sunrpc / svc.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  13.2 KB  |  423 lines
  1. /*
  2.  * linux/include/linux/sunrpc/svc.h
  3.  *
  4.  * RPC server declarations.
  5.  *
  6.  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
  7.  */
  8.  
  9.  
  10. #ifndef SUNRPC_SVC_H
  11. #define SUNRPC_SVC_H
  12.  
  13. #include <linux/in.h>
  14. #include <linux/in6.h>
  15. #include <linux/sunrpc/types.h>
  16. #include <linux/sunrpc/xdr.h>
  17. #include <linux/sunrpc/auth.h>
  18. #include <linux/sunrpc/svcauth.h>
  19. #include <linux/wait.h>
  20. #include <linux/mm.h>
  21.  
  22. /*
  23.  * This is the RPC server thread function prototype
  24.  */
  25. typedef int        (*svc_thread_fn)(void *);
  26.  
  27. /*
  28.  *
  29.  * RPC service thread pool.
  30.  *
  31.  * Pool of threads and temporary sockets.  Generally there is only
  32.  * a single one of these per RPC service, but on NUMA machines those
  33.  * services that can benefit from it (i.e. nfs but not lockd) will
  34.  * have one pool per NUMA node.  This optimisation reduces cross-
  35.  * node traffic on multi-node NUMA NFS servers.
  36.  */
  37. struct svc_pool {
  38.     unsigned int        sp_id;            /* pool id; also node id on NUMA */
  39.     spinlock_t        sp_lock;    /* protects all fields */
  40.     struct list_head    sp_threads;    /* idle server threads */
  41.     struct list_head    sp_sockets;    /* pending sockets */
  42.     unsigned int        sp_nrthreads;    /* # of threads in pool */
  43.     struct list_head    sp_all_threads;    /* all server threads */
  44. } ____cacheline_aligned_in_smp;
  45.  
  46. /*
  47.  * RPC service.
  48.  *
  49.  * An RPC service is a ``daemon,'' possibly multithreaded, which
  50.  * receives and processes incoming RPC messages.
  51.  * It has one or more transport sockets associated with it, and maintains
  52.  * a list of idle threads waiting for input.
  53.  *
  54.  * We currently do not support more than one RPC program per daemon.
  55.  */
  56. struct svc_serv {
  57.     struct svc_program *    sv_program;    /* RPC program */
  58.     struct svc_stat *    sv_stats;    /* RPC statistics */
  59.     spinlock_t        sv_lock;
  60.     unsigned int        sv_nrthreads;    /* # of server threads */
  61.     unsigned int        sv_max_payload;    /* datagram payload size */
  62.     unsigned int        sv_max_mesg;    /* max_payload + 1 page for overheads */
  63.     unsigned int        sv_xdrsize;    /* XDR buffer size */
  64.  
  65.     struct list_head    sv_permsocks;    /* all permanent sockets */
  66.     struct list_head    sv_tempsocks;    /* all temporary sockets */
  67.     int            sv_tmpcnt;    /* count of temporary sockets */
  68.     struct timer_list    sv_temptimer;    /* timer for aging temporary sockets */
  69.     sa_family_t        sv_family;    /* listener's address family */
  70.  
  71.     char *            sv_name;    /* service name */
  72.  
  73.     unsigned int        sv_nrpools;    /* number of thread pools */
  74.     struct svc_pool *    sv_pools;    /* array of thread pools */
  75.  
  76.     void            (*sv_shutdown)(struct svc_serv *serv);
  77.                         /* Callback to use when last thread
  78.                          * exits.
  79.                          */
  80.  
  81.     struct module *        sv_module;    /* optional module to count when
  82.                          * adding threads */
  83.     svc_thread_fn        sv_function;    /* main function for threads */
  84. };
  85.  
  86. /*
  87.  * We use sv_nrthreads as a reference count.  svc_destroy() drops
  88.  * this refcount, so we need to bump it up around operations that
  89.  * change the number of threads.  Horrible, but there it is.
  90.  * Should be called with the BKL held.
  91.  */
  92. static inline void svc_get(struct svc_serv *serv)
  93. {
  94.     serv->sv_nrthreads++;
  95. }
  96.  
  97. /*
  98.  * Maximum payload size supported by a kernel RPC server.
  99.  * This is use to determine the max number of pages nfsd is
  100.  * willing to return in a single READ operation.
  101.  *
  102.  * These happen to all be powers of 2, which is not strictly
  103.  * necessary but helps enforce the real limitation, which is
  104.  * that they should be multiples of PAGE_CACHE_SIZE.
  105.  *
  106.  * For UDP transports, a block plus NFS,RPC, and UDP headers
  107.  * has to fit into the IP datagram limit of 64K.  The largest
  108.  * feasible number for all known page sizes is probably 48K,
  109.  * but we choose 32K here.  This is the same as the historical
  110.  * Linux limit; someone who cares more about NFS/UDP performance
  111.  * can test a larger number.
  112.  *
  113.  * For TCP transports we have more freedom.  A size of 1MB is
  114.  * chosen to match the client limit.  Other OSes are known to
  115.  * have larger limits, but those numbers are probably beyond
  116.  * the point of diminishing returns.
  117.  */
  118. #define RPCSVC_MAXPAYLOAD    (1*1024*1024u)
  119. #define RPCSVC_MAXPAYLOAD_TCP    RPCSVC_MAXPAYLOAD
  120. #define RPCSVC_MAXPAYLOAD_UDP    (32*1024u)
  121.  
  122. extern u32 svc_max_payload(const struct svc_rqst *rqstp);
  123.  
  124. /*
  125.  * RPC Requsts and replies are stored in one or more pages.
  126.  * We maintain an array of pages for each server thread.
  127.  * Requests are copied into these pages as they arrive.  Remaining
  128.  * pages are available to write the reply into.
  129.  *
  130.  * Pages are sent using ->sendpage so each server thread needs to
  131.  * allocate more to replace those used in sending.  To help keep track
  132.  * of these pages we have a receive list where all pages initialy live,
  133.  * and a send list where pages are moved to when there are to be part
  134.  * of a reply.
  135.  *
  136.  * We use xdr_buf for holding responses as it fits well with NFS
  137.  * read responses (that have a header, and some data pages, and possibly
  138.  * a tail) and means we can share some client side routines.
  139.  *
  140.  * The xdr_buf.head kvec always points to the first page in the rq_*pages
  141.  * list.  The xdr_buf.pages pointer points to the second page on that
  142.  * list.  xdr_buf.tail points to the end of the first page.
  143.  * This assumes that the non-page part of an rpc reply will fit
  144.  * in a page - NFSd ensures this.  lockd also has no trouble.
  145.  *
  146.  * Each request/reply pair can have at most one "payload", plus two pages,
  147.  * one for the request, and one for the reply.
  148.  * We using ->sendfile to return read data, we might need one extra page
  149.  * if the request is not page-aligned.  So add another '1'.
  150.  */
  151. #define RPCSVC_MAXPAGES        ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE \
  152.                 + 2 + 1)
  153.  
  154. static inline u32 svc_getnl(struct kvec *iov)
  155. {
  156.     __be32 val, *vp;
  157.     vp = iov->iov_base;
  158.     val = *vp++;
  159.     iov->iov_base = (void*)vp;
  160.     iov->iov_len -= sizeof(__be32);
  161.     return ntohl(val);
  162. }
  163.  
  164. static inline void svc_putnl(struct kvec *iov, u32 val)
  165. {
  166.     __be32 *vp = iov->iov_base + iov->iov_len;
  167.     *vp = htonl(val);
  168.     iov->iov_len += sizeof(__be32);
  169. }
  170.  
  171. static inline __be32 svc_getu32(struct kvec *iov)
  172. {
  173.     __be32 val, *vp;
  174.     vp = iov->iov_base;
  175.     val = *vp++;
  176.     iov->iov_base = (void*)vp;
  177.     iov->iov_len -= sizeof(__be32);
  178.     return val;
  179. }
  180.  
  181. static inline void svc_ungetu32(struct kvec *iov)
  182. {
  183.     __be32 *vp = (__be32 *)iov->iov_base;
  184.     iov->iov_base = (void *)(vp - 1);
  185.     iov->iov_len += sizeof(*vp);
  186. }
  187.  
  188. static inline void svc_putu32(struct kvec *iov, __be32 val)
  189. {
  190.     __be32 *vp = iov->iov_base + iov->iov_len;
  191.     *vp = val;
  192.     iov->iov_len += sizeof(__be32);
  193. }
  194.  
  195. union svc_addr_u {
  196.     struct in_addr    addr;
  197.     struct in6_addr    addr6;
  198. };
  199.  
  200. /*
  201.  * The context of a single thread, including the request currently being
  202.  * processed.
  203.  */
  204. struct svc_rqst {
  205.     struct list_head    rq_list;    /* idle list */
  206.     struct list_head    rq_all;        /* all threads list */
  207.     struct svc_xprt *    rq_xprt;    /* transport ptr */
  208.     struct sockaddr_storage    rq_addr;    /* peer address */
  209.     size_t            rq_addrlen;
  210.  
  211.     struct svc_serv *    rq_server;    /* RPC service definition */
  212.     struct svc_pool *    rq_pool;    /* thread pool */
  213.     struct svc_procedure *    rq_procinfo;    /* procedure info */
  214.     struct auth_ops *    rq_authop;    /* authentication flavour */
  215.     u32            rq_flavor;    /* pseudoflavor */
  216.     struct svc_cred        rq_cred;    /* auth info */
  217.     void *            rq_xprt_ctxt;    /* transport specific context ptr */
  218.     struct svc_deferred_req*rq_deferred;    /* deferred request we are replaying */
  219.  
  220.     size_t            rq_xprt_hlen;    /* xprt header len */
  221.     struct xdr_buf        rq_arg;
  222.     struct xdr_buf        rq_res;
  223.     struct page *        rq_pages[RPCSVC_MAXPAGES];
  224.     struct page *        *rq_respages;    /* points into rq_pages */
  225.     int            rq_resused;    /* number of pages used for result */
  226.  
  227.     struct kvec        rq_vec[RPCSVC_MAXPAGES]; /* generally useful.. */
  228.  
  229.     __be32            rq_xid;        /* transmission id */
  230.     u32            rq_prog;    /* program number */
  231.     u32            rq_vers;    /* program version */
  232.     u32            rq_proc;    /* procedure number */
  233.     u32            rq_prot;    /* IP protocol */
  234.     unsigned short
  235.                 rq_secure  : 1;    /* secure port */
  236.  
  237.     union svc_addr_u    rq_daddr;    /* dest addr of request
  238.                          *  - reply from here */
  239.  
  240.     void *            rq_argp;    /* decoded arguments */
  241.     void *            rq_resp;    /* xdr'd results */
  242.     void *            rq_auth_data;    /* flavor-specific data */
  243.  
  244.     int            rq_reserved;    /* space on socket outq
  245.                          * reserved for this request
  246.                          */
  247.  
  248.     struct cache_req    rq_chandle;    /* handle passed to caches for 
  249.                          * request delaying 
  250.                          */
  251.     /* Catering to nfsd */
  252.     struct auth_domain *    rq_client;    /* RPC peer info */
  253.     struct auth_domain *    rq_gssclient;    /* "gss/"-style peer info */
  254.     struct svc_cacherep *    rq_cacherep;    /* cache info */
  255.     struct knfsd_fh *    rq_reffh;    /* Referrence filehandle, used to
  256.                          * determine what device number
  257.                          * to report (real or virtual)
  258.                          */
  259.     int            rq_splice_ok;   /* turned off in gss privacy
  260.                          * to prevent encrypting page
  261.                          * cache pages */
  262.     wait_queue_head_t    rq_wait;    /* synchronization */
  263.     struct task_struct    *rq_task;    /* service thread */
  264. };
  265.  
  266. /*
  267.  * Rigorous type checking on sockaddr type conversions
  268.  */
  269. static inline struct sockaddr_in *svc_addr_in(const struct svc_rqst *rqst)
  270. {
  271.     return (struct sockaddr_in *) &rqst->rq_addr;
  272. }
  273.  
  274. static inline struct sockaddr_in6 *svc_addr_in6(const struct svc_rqst *rqst)
  275. {
  276.     return (struct sockaddr_in6 *) &rqst->rq_addr;
  277. }
  278.  
  279. static inline struct sockaddr *svc_addr(const struct svc_rqst *rqst)
  280. {
  281.     return (struct sockaddr *) &rqst->rq_addr;
  282. }
  283.  
  284. /*
  285.  * Check buffer bounds after decoding arguments
  286.  */
  287. static inline int
  288. xdr_argsize_check(struct svc_rqst *rqstp, __be32 *p)
  289. {
  290.     char *cp = (char *)p;
  291.     struct kvec *vec = &rqstp->rq_arg.head[0];
  292.     return cp >= (char*)vec->iov_base
  293.         && cp <= (char*)vec->iov_base + vec->iov_len;
  294. }
  295.  
  296. static inline int
  297. xdr_ressize_check(struct svc_rqst *rqstp, __be32 *p)
  298. {
  299.     struct kvec *vec = &rqstp->rq_res.head[0];
  300.     char *cp = (char*)p;
  301.  
  302.     vec->iov_len = cp - (char*)vec->iov_base;
  303.  
  304.     return vec->iov_len <= PAGE_SIZE;
  305. }
  306.  
  307. static inline void svc_free_res_pages(struct svc_rqst *rqstp)
  308. {
  309.     while (rqstp->rq_resused) {
  310.         struct page **pp = (rqstp->rq_respages +
  311.                     --rqstp->rq_resused);
  312.         if (*pp) {
  313.             put_page(*pp);
  314.             *pp = NULL;
  315.         }
  316.     }
  317. }
  318.  
  319. struct svc_deferred_req {
  320.     u32            prot;    /* protocol (UDP or TCP) */
  321.     struct svc_xprt        *xprt;
  322.     struct sockaddr_storage    addr;    /* where reply must go */
  323.     size_t            addrlen;
  324.     union svc_addr_u    daddr;    /* where reply must come from */
  325.     struct cache_deferred_req handle;
  326.     size_t            xprt_hlen;
  327.     int            argslen;
  328.     __be32            args[0];
  329. };
  330.  
  331. /*
  332.  * List of RPC programs on the same transport endpoint
  333.  */
  334. struct svc_program {
  335.     struct svc_program *    pg_next;    /* other programs (same xprt) */
  336.     u32            pg_prog;    /* program number */
  337.     unsigned int        pg_lovers;    /* lowest version */
  338.     unsigned int        pg_hivers;    /* lowest version */
  339.     unsigned int        pg_nvers;    /* number of versions */
  340.     struct svc_version **    pg_vers;    /* version array */
  341.     char *            pg_name;    /* service name */
  342.     char *            pg_class;    /* class name: services sharing authentication */
  343.     struct svc_stat *    pg_stats;    /* rpc statistics */
  344.     int            (*pg_authenticate)(struct svc_rqst *);
  345. };
  346.  
  347. /*
  348.  * RPC program version
  349.  */
  350. struct svc_version {
  351.     u32            vs_vers;    /* version number */
  352.     u32            vs_nproc;    /* number of procedures */
  353.     struct svc_procedure *    vs_proc;    /* per-procedure info */
  354.     u32            vs_xdrsize;    /* xdrsize needed for this version */
  355.  
  356.     unsigned int        vs_hidden : 1;    /* Don't register with portmapper.
  357.                          * Only used for nfsacl so far. */
  358.  
  359.     /* Override dispatch function (e.g. when caching replies).
  360.      * A return value of 0 means drop the request. 
  361.      * vs_dispatch == NULL means use default dispatcher.
  362.      */
  363.     int            (*vs_dispatch)(struct svc_rqst *, __be32 *);
  364. };
  365.  
  366. /*
  367.  * RPC procedure info
  368.  */
  369. typedef __be32    (*svc_procfunc)(struct svc_rqst *, void *argp, void *resp);
  370. struct svc_procedure {
  371.     svc_procfunc        pc_func;    /* process the request */
  372.     kxdrproc_t        pc_decode;    /* XDR decode args */
  373.     kxdrproc_t        pc_encode;    /* XDR encode result */
  374.     kxdrproc_t        pc_release;    /* XDR free result */
  375.     unsigned int        pc_argsize;    /* argument struct size */
  376.     unsigned int        pc_ressize;    /* result struct size */
  377.     unsigned int        pc_count;    /* call count */
  378.     unsigned int        pc_cachetype;    /* cache info (NFS) */
  379.     unsigned int        pc_xdrressize;    /* maximum size of XDR reply */
  380. };
  381.  
  382. /*
  383.  * Function prototypes.
  384.  */
  385. struct svc_serv *svc_create(struct svc_program *, unsigned int, sa_family_t,
  386.                 void (*shutdown)(struct svc_serv *));
  387. struct svc_rqst *svc_prepare_thread(struct svc_serv *serv,
  388.                     struct svc_pool *pool);
  389. void           svc_exit_thread(struct svc_rqst *);
  390. struct svc_serv *  svc_create_pooled(struct svc_program *, unsigned int,
  391.             sa_family_t, void (*shutdown)(struct svc_serv *),
  392.             svc_thread_fn, struct module *);
  393. int           svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
  394. void           svc_destroy(struct svc_serv *);
  395. int           svc_process(struct svc_rqst *);
  396. int           svc_register(const struct svc_serv *, const unsigned short,
  397.                 const unsigned short);
  398.  
  399. void           svc_wake_up(struct svc_serv *);
  400. void           svc_reserve(struct svc_rqst *rqstp, int space);
  401. struct svc_pool *  svc_pool_for_cpu(struct svc_serv *serv, int cpu);
  402. char *           svc_print_addr(struct svc_rqst *, char *, size_t);
  403.  
  404. #define    RPC_MAX_ADDRBUFLEN    (63U)
  405.  
  406. /*
  407.  * When we want to reduce the size of the reserved space in the response
  408.  * buffer, we need to take into account the size of any checksum data that
  409.  * may be at the end of the packet. This is difficult to determine exactly
  410.  * for all cases without actually generating the checksum, so we just use a
  411.  * static value.
  412.  */
  413. static inline void svc_reserve_auth(struct svc_rqst *rqstp, int space)
  414. {
  415.     int added_space = 0;
  416.  
  417.     if (rqstp->rq_authop->flavour)
  418.         added_space = RPC_MAX_AUTH_SIZE;
  419.     svc_reserve(rqstp, space + added_space);
  420. }
  421.  
  422. #endif /* SUNRPC_SVC_H */
  423.